// eslint-disable-next-line jsx-a11y/href-no-hash,jsx-a11y/img-has-alt,jsx-a11y/no-marquee
/* eslint-disable function-paren-newline,react/jsx-closing-tag-location,react/jsx-indent,no-plusplus,import/first */
// eslint-disable-next-line import/first
import moment from 'moment';
import React, { Component } from 'react';
import reactComponentDebounce from 'react-component-debounce';
import { Form, InputNumber, Checkbox, DatePicker, Input, Cascader, Select, AutoComplete } from 'antd';
import * as commonServices from '../../../services/services';
import * as dropdownstatic from '../../../utils/dropdownstatic';
import * as utils from '../../../utils/utils';
import * as comFunc from '../ComFunc';
import styles from '../../../index.less';
import * as config from '../../../utils/config';
import Provinces from '../../../assets/provinces.json';
import Cities from '../../../assets/cities.json';
import Areas from '../../../assets/areas.json';

const FormItem = Form.Item;
const { Option } = Select;
const { TextArea } = Input;
const InputNumberA = reactComponentDebounce(500)(InputNumber);

/**
 * 控件组件
 * eg. <ShowType required/> required为必填
 */
class ShowType extends Component {
  /**   构造函数   */
  constructor(props) {
    super(props);
    this.state = {
      masterData: props.masterData, /*   主表数据(数据格式:对象)   */
      slaveData: props.slaveData, /*   从表数据(数据格式:数组)   */
      dataValue: props.dataValue, /*   本showType数据(数据格式:对象)   */
      disabled: props.disabled, /*   是否是查看状态(数据格式:布尔)   */
      dropDownData: [], /*   下拉数据集(如果不是下拉控件该值为空,数据格式:数组对象)   */
      isDropDownLoadFinish: !(props.showConfig.sDropDownType === 'sql' || props.showConfig.sDropDownType === 'const'), /*   下拉数据加载是否完成(下拉初始值是false,其它的都是true)   */
      isRender: false, /*   是否渲染(数据格式:布尔)   */
    };
    this.app = props.app; /*   系统数据(数据格式:对象)   */
    this.dateFormat = comFunc.getDateFormat(this.app.systemData); /*   系统参数日期格式化(数据格式:字符串)   */
    this.showConfig = props.showConfig; /*   关于本showType的所有配置(数据格式:对象)   */
    this.sActiveId = this.showConfig.sActiveId; /*   sql下拉新增tab页的sModelsId(数据格式:字符串)   */
    this.sModelsId = props.sModelsId; /*   窗体Id(数据格式:字符串)   */
    this.sId = props.sId; /*   主表Id(数据格式:字符串)   */
    this.sSlaveId = props.sSlaveId; /*   从表Id(主表控件这个字段为空,数据格式:字符串)   */
    this.sName = props.showConfig.sName; /*   控件名(数据格式:字符串)   */
    this.firstDataIndex = this.sName.substring(0, 1); /*   控件首字母(数据格式:字符串)   */
    this.sDropDownType = props.showConfig.sDropDownType; /*   下拉类型(数据格式:字符串)   */
    this.showName = props.showConfig.showName; /*   显示名(用于label,数据格式:字符串)   */
    this.formItemLayout = utils.isNotEmptyObject(this.props.formItemLayout) ?
      this.props.formItemLayout :
      { labelCol: { span: 7 }, wrapperCol: { span: 15 } }; /*   表格样式(主要是colspan和rowspan,数据格式:对象)   */
    this.max = utils.convertStrToNumber(props.showConfig.sMaxValue); /*   最大值(数据格式:数字)   */
    this.min = utils.convertStrToNumber(props.showConfig.sMinValue); /*   最小值(数据格式:数字)   */
    this.getFieldDecorator = utils.isUndefined(props.form) ?
      undefined :
      props.form.getFieldDecorator; /*   字段验证(数据格式:数字)   */
    this.must = utils.converStrToBoolean(props.showConfig.bNotEmpty); /*   是否为必填字段(数据格式:布尔)   */
    this.decimals = utils.convertUndefinedToEmptyObject(props.app.decimals); /*   数字格式化规范对象(数据格式:对象)   */
    this.floatNum = this.getFloatNum(this.sName, props.app.decimals); /*   数字格式化规范转换(数据格式:数字)   */
    this.floatPrice = this.getFloatPrice(this.floatNum); /*   价格格式化规范转换(数据格式:数字)   */
    this.sSqlCondition = comFunc.getSqlCondition(
      props.showConfig.sSqlCondition,
      this.sSlaveId,
      this.state.slaveData,
      this.state.masterData,
    ); /*   下拉sql查询的条件(数据格式:对象)   */
    this.iVisCount = utils.isEmptyNumber(props.showConfig.iVisCount) ? 1 : props.showConfig.iVisCount === 0 ? 1 : props.showConfig.iVisCount; /*   显示多上列下拉值,默认为1列(数据格式:数字)   */
    this.bFirstEmpty = utils.converStrToBoolean(props.showConfig.bFirstEmpty); /*   是否下拉空(数据格式:布尔)   */
    this.bNewRecord = utils.converStrToBoolean(props.showConfig.bNewRecord); /*   是否下拉新增(数据格式:布尔)   */
    this.textArea = props.textArea; /*   是否是大文本(数据格式:布尔)   */
    this.dataTotal = props.dataTotal; /*   是否是合计行(数据格式:布尔)   */
    this.bCanInput = props.showConfig.bCanInput; /*   是否可输入(数据格式:布尔)   */
    this.dispatch = props.dispatch; /*   路由跳转调用对象(数据格式:函数)   */
    this.onChange = this.isMasterControl() ? props.onMasterChange : props.onSlaveChange; /*   表单数据改变事件方法(数据格式:函数)   */
    this.onReturnMasterSelectValue = props.onReturnMasterSelectValue; /*   回带主表下拉数据(数据格式:函数)   */
    this.onReturnSlaveSelectValue = props.onReturnSlaveSelectValue; /*   回带从表下拉数据(数据格式:函数)   */
  }

  /**   渲染前只执行一次   */
  componentWillMount() {
    /*   如果是下拉控件,则要获取数据   */
    if ((this.sDropDownType === 'sql' || this.sDropDownType === 'const')
      && (this.firstDataIndex === 'i' || this.firstDataIndex === 'd' || this.firstDataIndex === 's')) {
      this.getDropDownData();
    }
  }

  /**   props改变的时候触发   */
  componentWillReceiveProps(nextProps) {
    /*   如果是下拉控件,则要获取数据(获取下拉数据前要先更新sqlCondition)   */
    if ((this.sDropDownType === 'sql' || this.sDropDownType === 'const')
      && (this.firstDataIndex === 'i' || this.firstDataIndex === 'd' || this.firstDataIndex === 's') && nextProps.isRender) {
      this.sSqlCondition = comFunc.getSqlCondition(
        this.showConfig.sSqlCondition,
        this.sSlaveId,
        nextProps.slaveData,
        nextProps.masterData,
      );
      this.getDropDownData();
    }
    /*   把需要更新的数据setState   */
    this.setState({
      masterData: nextProps.masterData,
      slaveData: nextProps.slaveData,
      dataValue: nextProps.dataValue,
      disabled: nextProps.disabled,
      isRender: utils.converStrToBoolean(nextProps.isRender),
    });
  }

  shouldComponentUpdate(nextProps, nextState) {
    return nextState.isRender;
  }

  /*   获取关联编号   */
  getRelationId = () => {
    /*   印件要取客户编号为关联编号   */
    if (this.sName === 'sProductId') {
      return this.sSqlCondition.sCustomerId;
    }
    /*   材料要取仓库编号为关联编号   */
    if (this.sName === 'sMaterialsId') {
      return this.sSqlCondition.sWareHouseId;
    }
    /*   其它情况都没有关联编号   */
    return '';
  }

  /*   获取sqlCondition对象   */
  getFloatPrice = (floatNum) => {
    /*   返回值声明   */
    let floatPrice = '';
    /*   返回值赋值   */
    if (utils.isUndefined(floatNum)) {
      for (let i = 0; i < floatNum; i++) {
        floatPrice += '\\d';
      }
    }
    /*   返回值   */
    return floatPrice;
  };

  /*   获取数字格式化规范   */
  getFloatNum = (sName, decimals) => {
    if (sName.toLowerCase().endsWith('price')) { /*   价格   */
      return decimals.dNetPrice;
    } else if (sName.toLowerCase().endsWith('money')) { /*   金额   */
      return decimals.dNetMoney;
    } else { /*   其它   */
      return 0;
    }
  };

  /**   获取下拉值   */
  getDropDownData = () => {
    /*   下拉类型区分   */
    if (this.sDropDownType === 'sql') { /*   数据下拉   */
      /*   获取关联编号   */
      const relationId = this.getRelationId();
      /*   获取下拉容器   */
      const dropDownContainer = dropdownstatic.getDropDownFactory(this.sName, relationId);
      /*   判断是否需要重新获取下拉值   */
      if (utils.isNotEmptyArr(dropDownContainer)) { /*   如果值全局变量中存在了就直接用这个   */
        /*   state赋值   */
        this.setState({
          dropDownData: dropDownContainer,
          isDropDownLoadFinish: true,
          isRender: true,
        });
        /*   回带下拉数据集   */
        this.returnSelectValueArr(dropDownContainer);
      } else { /*   如果值全局变量中不存在就重新获取   */
        this.getSqlDropDownData(relationId);
      }
    } else if (this.sDropDownType === 'const') { /*   常量下拉   */
      /*   常量下拉其实只取一次数据就可以啦,去过数据的会给state中的dropDownData赋值,所以dropDownData有值的情况就不需要再获取了   */
      if (utils.isEmptyArr(this.state.dropDownData)) {
        this.getConstDropDownData();
      }
    }
  };

  /**   获取常量下拉数据   */
  getConstDropDownData = () => {
    /*   从配置中获取常量下拉数据集   */
    const { showDropDown } = this.showConfig;
    /*   把常量下拉对象转换成数组格式来适配(最终state中dropDownData的值都是数组对象的形式)   */
    const dropDownContainer = utils.objectToArr(utils.convertStrToObj(showDropDown));
    /*   给state赋值   */
    this.setState({
      dropDownData: dropDownContainer,
      isDropDownLoadFinish: true,
      isRender: true,
    });
  };

  /**   获取sql下拉数据   */
  getSqlDropDownData = async (relationId) => {
    /*   地址   */
    const url = `${config.server_host}business/getSelectDataBysControlId/${this.showConfig.sId}?sModelsId=${this.sModelsId}`;
    /*   参数   */
    const body = {
      sKeyUpFilterName: '', /*   边输入边过滤,暂时没用   */
      sSqlCondition: utils.isEmptyObject(this.sSqlCondition) ? '' : this.sSqlCondition, /*   查询条件   */
    };
    /*   获取数据   */
    const json = await commonServices.postValueService(this.props.app.token, body, url);
    /*   code为1代表获取数据成功   */
    if (json.data.code === 1) {
      /*   获取数据集   */
      const { rows } = json.data.dataset;
      /*   执行条件   */
      if (utils.isNotEmptyArr(rows)) {
        /*   全局变量赋值   */
        dropdownstatic.setDropDownStorage(this.sName, rows, relationId);
        /*   state赋值   */
        this.setState({
          dropDownData: rows,
          isDropDownLoadFinish: true,
          isRender: true,
        });
        /*   回带下拉数据集   */
        this.returnSelectValueArr(rows);
      } else {
        /*   state赋值   */
        this.setState({
          isDropDownLoadFinish: true,
          isRender: true,
        });
      }
    }
  };

  /**   获取selectprops对象   */
  getSelectProps = () => {
    /*   返回值声明   */
    const obj = {
      showSearch: true, /*   是否有查找功能   */
      disabled: this.state.disabled /*   修改的时候传过来的数据   */
      || !this.state.isDropDownLoadFinish /*   下拉是否完成   */
      || (this.dataTotal && !this.isMasterControl()), /*   是否可编辑   */
      onChange: this.isMasterControl() ?
        this.handleSelectOptionEvent :
        this.handleSlaveSelectOptionEvent, /*   选择触发事件   */
      filterOption: this.filterOption, /*  搜索时过滤对应的 option 属性  */
    };
    /*   主表时才赋值value   */
    if (!this.isMasterControl()) {
      obj.value = this.getValueOfSelect(); /*   数据值   */
      obj.className = styles.editSelect;
    }
    /*   返回值   */
    return obj;
  };
  /**   获取selectOption对象   */
  getSelectOption = () => {
    /*   返回值声明   */
    const options = [];
    /*   执行条件   */
    if (utils.isNotEmptyArr(this.state.dropDownData)) {
      /*   遍历下拉数据   */
      for (const each of this.state.dropDownData) {
        /*   拼接optoin对象   */
        const option = <Option key={each.sId} value={each.sId}>{this.getOptionValues(each)}</Option>;
        /*   返回值赋值   */
        options.push(option);
      }
    }
    /*   下拉空处理   */
    if (this.bFirstEmpty) {
      options.push(<Option key=" ">--</Option>);
    }
    /*   下拉新增处理   */
    if (this.bNewRecord) {
      options.unshift(<Option key="000">NEW RECORD</Option>);
    }
    /*   返回值   */
    return options;
  };

  /**   获取optionValue对象   */
  getOptionValues = (data) => {
    /*   返回值声明   */
    let res = '';
    /*   计数器   */
    let count = 1;
    /*   遍历每一条数据   */
    for (const key of Object.keys(data)) {
      /*   这里主要是为了实现配置中控制下拉的展现列数   */
      if (count <= this.iVisCount && key !== 'sId') {
        if (res === '') {
          res = data[key];
        } else {
          res = res.concat('-').concat(data[key]);
        }
        count += 1;
      }
    }
    /*   返回值   */
    return res;
  };

  /**   获取innerinput控件   */
  getInnerInput = (innerInputProps) => {
    if ((this.sDropDownType === 'sql' || this.sDropDownType === 'const')
      && (this.firstDataIndex === 'i' || this.firstDataIndex === 'd' || this.firstDataIndex === 's')) { /*   下拉选择框(数字和文本选择框才会下拉)   */
      if (this.bCanInput) { /*   文本输入下拉框   */
        return <AutoComplete {...this.getSelectProps()} >{this.getSelectOption()}</AutoComplete>;
      } else { /*   普通下拉框   */
        return <Select {...this.getSelectProps()} >{this.getSelectOption()}</Select>;
      }
    } else if (this.firstDataIndex === 'i' || this.firstDataIndex === 'd') { /*   数字输入框(整形i和浮点型d)   */
      return <InputNumberA {...innerInputProps} />;
    } else if (this.firstDataIndex === 'b') { /*   选择框(布尔类型b)   */
      return <Checkbox {...innerInputProps}>{this.showName}</Checkbox>;
    } else if (this.firstDataIndex === 't') { /*   时间选择框(时间类型t)   */
      return <DatePicker {...innerInputProps} />;
    } else if (this.firstDataIndex === 's') { /*   文本输入框(文本s)   */
      if (this.props.textArea) { /*   大文本输入框   */
        return <TextArea {...innerInputProps} />;
      } else { /*   普通文本输入框   */
        return <Input {...innerInputProps} />;
      }
    } else if (this.firstDataIndex === 'c') { /*   地址联动框(联动下拉类型c)   */
      return <Cascader {...innerInputProps} />;
    } else { /*   文本输入框(默认类型)   */
      return <Input {...innerInputProps} />;
    }
  };

  /**   获取select类型的value值   */
  getValueOfSelect = () => {
    if (utils.isUndefined(this.state.dataValue)) {
      return '';
    } else if (utils.isUndefined(this.state.dataValue.value)) {
      return '';
    } else {
      return this.state.dataValue.value;
    }
  };

  /**   获取number类型的value值   */
  getValueOfNumber = () => {
    if (utils.isUndefined(this.state.dataValue)) {
      return undefined;
    } else if (utils.isEmptyNumber(this.state.dataValue.value)) {
      return undefined;
    } else {
      return this.state.dataValue.value;
    }
  };

  /**   获取date类型的value值   */
  getValueOfDate = () => {
    const { dataValue } = this.state;
    if (utils.isUndefined(dataValue) || utils.isUndefined(dataValue.value)) {
      return null;
    } else if (typeof dataValue.value === 'string') {
      if (utils.isEmptyStr(dataValue.value)) {
        return null;
      } else {
        return moment(dataValue.value);
      }
    } else {
      return dataValue.value;
    }
  };

  /**   获取obj类型的value值   */
  getValueOfObj = () => {
    if (utils.isUndefined(this.state.dataValue)) {
      return {};
    }
    return utils.convertUndefinedToEmptyArr(this.state.dataValue.value);
  };

  /**   获取date类型的value值   */
  getValueOfStr = () => {
    if (utils.isUndefined(this.state.dataValue)) {
      return '';
    }
    return utils.strUndefinedToEmpty(this.state.dataValue.value);
  };

  /**   获取boolean类型的value值   */
  getValueOfBoolean = () => {
    if (utils.isUndefined(this.state.dataValue)) {
      return false;
    }
    return utils.converNumStrToBoolean(this.state.dataValue.value);
  };

  /**   获取innerinput控件参数   */
  getInnerInputProps = () => {
    /*   主表和从表的innerinputprops对象有区别   */
    if (this.isMasterControl()) { /*   主表   */
      return this.getInnerInputPropsMaster();
    } else { /*   主从表   */
      return this.getInnerInputPropsSlave();
    }
  };

  /**   获取innerinput控件参数(从)   */
  getInnerInputPropsSlave = () => {
    /*   返回值声明   */
    let obj = {};
    if (this.firstDataIndex === 'i' || this.firstDataIndex === 'd') { /*   数字输入框(整形i和浮点型d)   */
      obj = this.getNumberInnerInputPropsSlave();
    } else if (this.firstDataIndex === 'b') { /*   选择框(布尔类型b)   */
      obj = this.getBooleanInnerInputPropsSlave();
    } else if (this.firstDataIndex === 't') { /*   时间选择框(时间类型t)   */
      obj = this.getDateInnerInputPropsSlave();
    } else if (this.firstDataIndex === 's') { /*   文本输入框(文本s)   */
      obj = this.getTextInnerInputPropsSlave();
    } else if (this.firstDataIndex === 'c') { /*   地址联动框(联动下拉类型c)   */
      obj = this.getAddressInnerInputPropsSlave();
    }
    /*   返回值   */
    return obj;
  };

  /*   获取地址innerinputprops对象(从)   */
  getAddressInnerInputPropsSlave = () => {
    /*   返回值   */
    const obj = {
      disabled: this.state.disabled || this.dataTotal, /*   是否可编辑   */
      placeholder: '请选择省市区', /*   预期值的提示信息   */
      options: this.getProvinceCityAreaData(), /*   数据   */
      changeOnSelect: true, /*   对每个选择值进行更改   */
      onChange: this.handleSlaveSelectOptionEvent, /*   数据改变回带到父组件   */
      value: this.getValueOfObj(), /*   数据值   */
    };
    /*   返回值   */
    return obj;
  };

  /*   获取文本innerinputprops对象(从)   */
  getTextInnerInputPropsSlave = () => {
    /*   返回值声明   */
    const obj = {
      disabled: this.state.disabled || this.dataTotal, /*   是否可编辑   */
      onChange: e => this.handleSlaveSelectOptionEvent(e.target.value), /*   数据改变回带到父组件   */
      value: this.getValueOfStr(), /*   数据值   */
    };
    /*   最大值最小值   */
    if (typeof this.max === 'number') {
      obj.maxLength = this.max; /*   最大长度   */
    }
    /*   返回值   */
    return obj;
  };

  /*   获取日期innerinputprops对象(从)   */
  getDateInnerInputPropsSlave = () => {
    /*   返回值声明   */
    const obj = {
      disabled: this.state.disabled || this.dataTotal, /*   是否可编辑   */
      onChange: this.handleSlaveSelectOptionEvent, /*   数据改变回带到父组件   */
      format: this.dateFormat, /*   格式化规则   */
      disabledDate: this.getDataMaxAndMin, /*   不可选日期   */
    };
    /*   值填充   */
    const value = this.getValueOfDate();
    if (utils.isNotUndefined(value)) {
      obj.value = value;
    }
    /*   返回值   */
    return obj;
  };

  /*   获取布尔innerinputprops对象(从)   */
  getBooleanInnerInputPropsSlave = () => {
    /*   返回值声明   */
    const obj = {
      disabled: this.state.disabled || this.dataTotal, /*   是否可编辑   */
      onChange: this.handleSlaveSelectOptionEvent, /*   数据改变回带到父组件   */
      checked: this.getValueOfBoolean(), /*   是否选中   */
    };
    /*   返回值   */
    return obj;
  };

  /*   获取数字innerinputprops对象(从)   */
  getNumberInnerInputPropsSlave = () => {
    /*   返回值声明   */
    const obj = {
      className: styles.inputNum, /*   样式名称   */
      disabled: this.state.disabled || this.dataTotal, /*   是否可编辑   */
      onChange: value => this.handleSlaveSelectOptionEvent(utils.convertStrToNumber0(value)), /*   数据改变回带到父组件   */
    };
    /*   最大值最小值   */
    if (typeof this.max === 'number') {
      obj.max = this.max; /*   最大值   */
    }
    if (typeof this.min === 'number') {
      obj.min = this.max; /*   最小值   */
    }
    /*   浮点型需要格式化   */
    if (this.firstDataIndex === 'd') {
      obj.precision = this.floatNum;
      obj.formatter = value => this.limitDecimals(value);
      obj.parser = value => this.limitDecimals(value);
    }
    /*   值填充   */
    const value = this.getValueOfNumber();
    if (utils.isNotUndefined(value)) {
      obj.value = value;
    }
    /*   返回值   */
    return obj;
  };

  /**   获取innerinput控件参数(主)   */
  getInnerInputPropsMaster = () => {
    /*   返回值声明   */
    let obj = {};
    if (this.firstDataIndex === 'i' || this.firstDataIndex === 'd') { /*   数字输入框(整形i和浮点型d)   */
      obj = this.getNumberInnerInputPropsMaster();
    } else if (this.firstDataIndex === 'b') { /*   选择框(布尔类型b)   */
      obj = this.getBooleanInnerInputPropsMaster();
    } else if (this.firstDataIndex === 't') { /*   时间选择框(时间类型t)   */
      obj = this.getDateInnerInputPropsMaster();
    } else if (this.firstDataIndex === 's') { /*   文本输入框(文本s)   */
      if (this.props.textArea) { /*   大文本输入框   */
        obj = this.getTextAreaInnerInputPropsMaster();
      } else { /*   普通文本输入框   */
        obj = this.getTextInnerInputPropsMaster();
      }
    } else if (this.firstDataIndex === 'c') { /*   地址联动框(联动下拉类型c)   */
      obj = this.getAddressInnerInputPropsMaster();
    }
    /*   返回值   */
    return obj;
  };

  /*   获取地址innerinputprops对象(主)   */
  getAddressInnerInputPropsMaster = () => {
    return {
      disabled: this.state.disabled, /*   是否可编辑   */
      placeholder: '请选择省市区', /*   预期值的提示信息   */
      options: this.getProvinceCityAreaData(), /*   数据   */
      changeOnSelect: true, /*   对每个选择值进行更改   */
      onChange: this.handleSelectOptionEvent, /*   数据改变回带到父组件   */
    };
  };

  /*   获取文本innerinputprops对象(主)   */
  getTextInnerInputPropsMaster = () => {
    /*   返回值声明   */
    const obj = {
      disabled: this.state.disabled && this.state.isDropDownLoadFinish, /*   是否可编辑   */
      onChange: e => this.handleSelectOptionEvent(e.target.value), /*   数据改变回带到父组件   */
    };
    /*   最大值最小值   */
    if (typeof this.max === 'number') {
      obj.maxLength = this.max; /*   最大长度   */
    }
    /*   返回值   */
    return obj;
  };

  /*   获取大文本innerinputprops对象(主)   */
  getTextAreaInnerInputPropsMaster = () => {
    /*   返回值声明   */
    const obj = {
      disabled: this.state.disabled, /*   是否可编辑   */
      rows: 4, /*   纵跨度   */
      onChange: this.handleSelectOptionEvent, /*   数据改变回带到父组件   */
    };
    /*   最大值最小值   */
    if (typeof this.max === 'number') {
      obj.maxLength = this.max; /*   最大长度   */
    }
    return obj;
  };

  /*   获取日期最大值和最小值   */
  getDataMaxAndMin = (current) => {
    return this.getDataMax(current) || this.getDataMin(current);
  }

  /*   获取日期最大值   */
  getDataMax = (current) => {
    return utils.isNotEmptyStr(this.max) && current.endOf('day') > moment(this.max).endOf('day');
  }

  /*   获取日期最小值   */
  getDataMin = (current) => {
    return utils.isNotEmptyStr(this.min) && current.endOf('day') < moment(this.min).endOf('day');
  }

  /*   获取时间innerinputprops对象(主)   */
  getDateInnerInputPropsMaster = () => {
    return {
      disabled: this.state.disabled, /*   是否可编辑   */
      style: { width: 'auto', display: 'block' }, /*   样式   */
      format: this.dateFormat, /*   格式化规则   */
      onChange: this.handleSelectOptionEvent, /*   数据改变回带到父组件   */
      disabledDate: this.getDataMaxAndMin, /*   不可选日期   */
    };
  };

  /*   获取布尔innerinputprops对象(主)   */
  getBooleanInnerInputPropsMaster = () => {
    return {
      disabled: this.state.disabled, /*   是否显示   */
      onChange: this.handleSelectOptionEvent, /*   数据改变回带到父组件   */
    };
  };

  /*   获取数字innerinputprops对象(主)   */
  getNumberInnerInputPropsMaster = () => {
    /*   如果是浮点型并且有格式规定,display类型需要变为block   */
    let display = 'inline-block';
    if (this.firstDataIndex === 'd' && this.floatNum !== 0) {
      display = 'block';
    }
    /*   返回值赋值   */
    const obj = {
      style: { width: 'auto', display, marginRight: 0 }, /*   样式   */
      disabled: this.state.disabled && this.state.isDropDownLoadFinish, /*   是否显示   */
      onChange: this.handleSelectOptionEvent, /*   数据改变回带到父组件   */
    };
    /*   最大值最小值   */
    if (typeof this.max === 'number') {
      obj.max = this.max; /*   最大值   */
    }
    if (typeof this.min === 'number') {
      obj.min = this.max; /*   最小值   */
    }
    /*   格式规格不为0就在props里设置一下   */
    if (this.firstDataIndex === 'd' && this.floatNum !== 0) {
      obj.precision = this.floatNum;
    }
    /*   返回值   */
    return obj;
  };

  /*   获取省市区数据   */
  getProvinceCityAreaData = () => {
    /*   返回值声明   */
    const options = [];
    /*   获取省数据   */
    this.getProvinceData(options);
    /*   获取市数据   */
    this.getCityData(options);
    /*   获取区数据   */
    this.getAreaData(options);
    /*   返回值   */
    return options;
  };

  /*   获取省数据   */
  getProvinceData = (options) => {
    Provinces.forEach((childProvince) => {
      options.push({
        value: childProvince.name, /*   文字   */
        label: childProvince.name, /*   标签   */
        code: childProvince.code, /*   编码   */
        children: [], /*   子节点(city)   */
      });
    });
  };

  /*   获取市数据   */
  getCityData = (options) => {
    options.forEach((childProvince) => {
      const cities = Cities.filter(item => item.provinceCode === childProvince.code);
      if (cities.length > 0) {
        cities.forEach((childCity) => {
          childProvince.children.push({
            value: childCity.name, /*   文字   */
            label: childCity.name, /*   标签   */
            code: childCity.code, /*   编码   */
            children: [], /*   子节点(area)   */
          });
        });
      }
    });
  };

  /*   获取区数据   */
  getAreaData = (options) => {
    options.forEach((childProvince) => {
      const cities = childProvince.children;
      cities.forEach((childCity) => {
        const areas = Areas.filter((item => item.cityCode === childCity.code));
        if (areas.length > 0) {
          areas.forEach((area) => {
            childCity.children.push({
              value: area.name, /*   文字   */
              label: area.name, /*   标签   */
              code: area.code, /*   编码   */
            });
          });
        }
      });
    });
  };

  /*   获取formitemprops对象   */
  getOutFormItemProps = () => {
    /*   主表和从表的formitemprops对象有区别   */
    if (this.isMasterControl()) { /*   主表   */
      return this.getOutFormItemPropsMaster();
    } else { /*   从表   */
      return this.getOutFormItemPropsSlave();
    }
  };

  /*   获取formitemprops对象(主)   */
  getOutFormItemPropsMaster = () => {
    /*   返回值声明   */
    let obj = {};
    if (this.firstDataIndex === 'i'
      || this.firstDataIndex === 'd'
      || this.firstDataIndex === 't'
      || this.firstDataIndex === 's'
      || this.firstDataIndex === 'c') { /*   数字输入框(整形i和浮点型d),
                                                   时间选择框(时间类型t),
                                                   文本输入框(文本s),
                                                   地址联动框(联动下拉类型c)   */
      obj = {
        label: this.showName, /*   标签   */
        className: styles.formItemMargin, /*   样式名称   */
        ...this.formItemLayout, /*   主要是rowspan和colspan   */
      };
    } else if (this.firstDataIndex === 'b') { /*   选择框(布尔类型b)   */
      obj = {
        label: this.showName, /*   标签   */
        className: styles.formItemMag10, /*   样式名称   */
        ...this.formItemLayout, /*   主要是rowspan和colspan   */
      };
    }
    /*   返回值   */
    return obj;
  };

  /*   获取formitemprops对象(从)   */
  getOutFormItemPropsSlave = () => {
    /*   返回值声明   */
    let obj = {};
    if (this.firstDataIndex === 'i'
      || this.firstDataIndex === 'd'
      || this.firstDataIndex === 'c'
      || this.sDropDownType === 'sql'
      || this.sDropDownType === 'const') { /*   数字输入框(整形i和浮点型d),
                                                      时间选择框(时间类型t),
                                                      文本输入框(文本s),
                                                      地址联动框(联动下拉类型c),
                                                      所有的下拉(从表只有文字下拉,分常量和sql两种)   */
      obj = {
        className: styles.formItemMargin0, /*   样式名称   */
      };
    } else if (this.firstDataIndex === 'b') { /*   选择框(布尔类型b)   */
      obj = {
        className: styles.tableCheckBox, /*   样式名称   */
      };
    } else if (this.firstDataIndex === 't') { /*   时间选择框(时间类型t)   */
      obj = {
        className: styles.tableDataPicker, /*   样式名称   */
      };
    } else if (this.firstDataIndex === 's') { /*   文本输入框(文本s)   */
      obj = {
        className: styles.editInput, /*   样式名称   */
      };
    }
    /*   返回值   */
    return obj;
  };

  /*   获取fielddecoratorprops对象   */
  getFieldDecoratorProps = () => {
    /*   返回值声明   */
    let obj = {};
    if (this.firstDataIndex === 'i' || this.firstDataIndex === 'd' || this.firstDataIndex === 't' || this.firstDataIndex === 's' || this.firstDataIndex === 'b') { /*   数字输入框(整形i和浮点型d),时间选择框(时间类型t),文本输入框(文本s),选择框(布尔类型b)   */
      obj = { rules: [{ required: this.must, message: `${this.showName}为必填项` }] };
    } else if (this.firstDataIndex === 'c') { /*   地址联动框(联动下拉类型c)   */
      obj = {
        initialValue: ['北京市', '市辖区', '东城区'], /*   默认值   */
        rules: [{ required: this.must, message: `${this.showName}为必填项` }], /*   规则   */
      };
    }
    /*   返回值   */
    return obj;
  };

  /**   回带下拉数据集   */
  returnSelectValueArr = (valueArr) => {
    if (this.isMasterControl()) { /*   主表数据回带   */
      this.onReturnMasterSelectValue(this.sName, valueArr);
    } else { /*   从表数据回带   */
      this.onReturnSlaveSelectValue(this.sName, valueArr, this.sSlaveId);
    }
  };

  /*   是否是主表控件   */
  isMasterControl = () => {
    return utils.isEmptyStr(this.sSlaveId);
  };

  /**   处理下拉选择事件   */
  handleSelectOptionEvent = (value) => {
    /*   下拉新增单独处理   */
    if (this.sDropDownType === 'sql' && value === '000') {
      this.handleSqlDropDownNewRecord();
      return;
    }
    /*   回带值声明   */
    const returnValue = {};
    /*   回带值赋值(sName:value)   */
    returnValue[this.sName] = this.firstDataIndex === 's' && this.props.textArea ? value.target.value : value;
    /*   调用父组件的回带函数   */
    this.onChange(returnValue);
  };

  /**   处理从表change事件   */
  handleSlaveSelectOptionEvent = (value) => {
    /*   下拉新增单独处理   */
    if (this.sDropDownType === 'sql' && value === '000') {
      this.handleSqlDropDownNewRecord();
      return;
    }
    /*   回带值声明   */
    const returnValue = {};
    /*   回带值赋值(sName:value)   */
    returnValue[this.sName] = value;
    /*   调用父组件的回带函数   */
    this.onChange(returnValue, this.sSlaveId);
  };
  /**  搜索时过滤对应的 option 属性 */
  filterOption = (input, option) => {
    return option.props.children.toLowerCase().indexOf(input.toLowerCase()) >= 0;
  };

  /**   sql下拉新增处理   */
  handleSqlDropDownNewRecord = () => {
    /*   待用数据声明   */
    const sTabId = this.app.currentPane.key; /*   当前标签页TabId   */
    /*   接口地址   */
    const sNameUrl = `${config.server_host}gdsmodule/getGdsmoduleById/${this.sActiveId}?sModelsId=${this.sActiveId}`;
    /*   接口参数   */
    const payload = {
      url: sNameUrl,
      sParentId: sTabId,
    };
    /*   调用接口   */
    this.dispatch({ type: 'content/onRouter', payload });
  };

  // noinspection JSAnnotator
  // limitDecimals = (value) => {
  //   return utils.filterDisNumberN(value, this.floatNum);
  // };
  // noinspection JSAnnotator
  limitDecimals = (values: string | number): string => {
    let reg = '';
    if (this.floatNum > 0) {
      reg = `^(\\d+).(${this.floatPrice})*$`;
    } else {
      reg = '^(\\d+).(\\d\\d\\d\\d\\d\\d)*$';
    }
    if (typeof values === 'string') {
      if (values !== undefined && values.indexOf('.') <= -1) {
        reg = '^(\\d+)*$';
        return !isNaN(Number(values)) ? values.replace(new RegExp(reg), '$1') : '';
      } else {
        return !isNaN(Number(values)) ? values.replace(new RegExp(reg), '$1.$2') : '';
      }
    } else if (typeof values === 'number') {
      if (values !== undefined && String(values).indexOf('.') <= -1) {
        reg = '^(\\d+)*$';
        return !isNaN(values) ? String(values).replace(new RegExp(reg), '$1') : '';
      } else {
        return !isNaN(values) ? String(values).replace(new RegExp(reg), '$1.$2') : '';
      }
    } else {
      return '';
    }
  };

  /**   渲染   */
  render() {
    /*   获取innerinput控件参数   */
    const innerInputProps = this.getInnerInputProps();

    /*   获取innerinput控件   */
    const innerInput = this.getInnerInput(innerInputProps);

    /*   获取outformitem控件参数   */
    const outFormItemProps = this.getOutFormItemProps();

    /*   获取fieldDecorator参数   */
    const fieldDecoratorProps = this.getFieldDecoratorProps();

    /*   通用组件(主表存在getFieldDecorator表单验证,而从表则不需要)   */
    const commonAssembly = (<FormItem {...outFormItemProps}>
      {this.isMasterControl() ?
        this.getFieldDecorator(this.sName, fieldDecoratorProps)(innerInput) :
        innerInput}
    </FormItem>);

    /*   页面输出   */
    return (
      <div>
        {commonAssembly}
      </div>
    );
  }
}

export default ShowType;
